package writtenTraining.day41;

import java.util.*;

/**
 * day41:(1)模拟：MT2 棋子翻转
 */

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param A int整型二维数组 
     * @param f int整型二维数组 
     * @return int整型二维数组
     */
    public int[][] flipChess (int[][] A, int[][] f) {
        // 模拟
        int[] dx= {0,0,-1,1}, dy = {-1,1,0,0};
        int row = A.length, col = A[0].length;

        for(int i = 0; i < f.length; i++) {
            int x = f[i][0] - 1, y = f[i][1] - 1;
            // 环顾四周
            for(int k = 0; k < 4; k++) {
                int kx = x + dx[k];
                int ky = y + dy[k];
                if(kx >= 0 && kx < row
                && ky >= 0 && ky < col 
                ) {
                    // 判断翻转
                    if(A[kx][ky] == 0) {
                        A[kx][ky] = 1;
                    } else if(A[kx][ky] == 1) {
                        A[kx][ky] = 0;
                    }
                }
            }
        }

        return A;
    }
}




class Main {
    public static void main(String[] args) {
//         广度优先遍历
        //         输入数据
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int[] nums = new int[n+1];
        for(int i = 1; i <= n; i++) {
            nums[i] = in.nextInt();
        }

        if(nums[1] <= 0) {
            System.out.println(-1);
        } else {

            int ret = bfs(nums,n);
            // 输出结果
            System.out.println(ret == 0 ? -1 : ret);
        }

    }

    public static Integer bfs(int[] nums,int n ) {
        // 进行bfs
        Queue<Integer> queue = new LinkedList<>();
        queue.add(1);
        int ret = 0;
        while(!queue.isEmpty()) {
            ret++;
            int sz = queue.size();
            for(int i = 0 ; i < sz; i++) {
                int index = queue.poll();
                for(int j = index + 1;
                    j <= index + nums[index]; ++j) {
//                         如果到达结果就返回
                    if(j == n) {
                        return ret;
                    }

//                         否则加入 j
                    if(nums[j] > 0) {
                        queue.add(j);
                    }
                }
            }
        }

        return ret;
    }
}

/**
 * day41：（2）动态规划 + 打家劫舍 + 区间dp：宵暗的妖怪
 */


 class Main1 {
    public static void main(String[] args) {

//         动态规划 + 打家劫舍 + 区间dp
        //         输入数据
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        long[] nums = new long[n+1];

        for(int i = 1 ; i <= n; i++) {
            nums[i]  = in.nextLong();
        }

        // 创建dp
        long[] dp = new long[n+1];
//         初始化
//         填表
        for(int i = 3; i <= n; i++) {
//             如果是以这个区间为结尾
//             dp[i-3]+nums[i-1] 为在前面那个区间的基础上 加上中间元素
//             如果不在这个区间
//             就继承前面的dp[i-1]的这个位置
            dp[i] = Math.max(dp[i-3]+nums[i-1],dp[i-1]);
        }


//         返回值
        System.out.println(dp[n]);
    }
}


/**
 * day41:(3) 广度优先遍历 + 贪心：过桥
 */


 class Main4 {
    public static void main(String[] args) {
//         广度优先遍历 + 贪心
        //         输入数据
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int[] nums = new int[n+1];
        for(int i = 1; i <= n; i++) {
            nums[i] = in.nextInt();
        }

        if(nums[1] <= 0) {
            System.out.println(-1);
        } else {

            int ret = bfs(nums,n);
            // 输出结果
            System.out.println(ret == 0 ? -1 : ret);
        }

    }

    public static Integer bfs(int[] nums,int n ) {
        // 进行bfs
        Queue<Integer> queue = new LinkedList<>();
        queue.add(1);
        int ret = 0;
        int INF= 0x3f3f3f3f;
        while(!queue.isEmpty()) {
            ret++;
            int sz = queue.size();
            for(int i = 0 ; i < sz; i++) {
                int index = queue.poll();
                int maxStep = -INF,maxIndex = -INF;
                int step = 0;
                for(int j = index + 1; j <= index + nums[index]; ++j) {
//                         如果到达结果就返回
                    if(j >= n) {
                        return ret;
                    }
                    if (nums[j] > 0) {
                        step = j + nums[j];
                    }
//                         否则加入 j
                    if(step > maxStep) {
                        maxStep = step;
                        maxIndex = j;
                    }
                }
                if (maxIndex != -INF)
                queue.add(maxIndex);
            }
        }

        return 0;
    }
}



